home *** CD-ROM | disk | FTP | other *** search
/ SGI Freeware 2002 November / SGI Freeware 2002 November - Disc 2.iso / dist / fw_glimpse.idb / usr / freeware / src / glimpse-3.0 / agrep / checksg.c.z / checksg.c
C/C++ Source or Header  |  1997-09-09  |  4KB  |  158 lines
  1. /* Copyright (c) 1994 Sun Wu, Udi Manber, Burra Gopal.  All Rights Reserved. */
  2. #include "agrep.h"
  3. #include "checkfile.h"
  4.  
  5. extern int errno;
  6. extern CHAR Progname[MAXNAME]; 
  7. extern int SGREP, PAT_FILE, PAT_BUFFER, EXITONERROR, SIMPLEPATTERN,
  8.     CONSTANT, D, NOUPPER, JUMP, I, LINENUM, INVERSE, WORDBOUND, WHOLELINE,
  9.     SILENT, DNA, BESTMATCH;
  10.  
  11. /* Make it an interface routine that tells you whether mgrep can be used for the pattern or not: must sneak and access global variable D though... */
  12. int
  13. checksg(Pattern, D, set)
  14. CHAR *Pattern; 
  15. int D;
  16. int set;    /* should I set flags SGREP and DNA? not if called from glimpse via library */
  17. {
  18.     char c;
  19.     int i, m;
  20.     int NOTSGREP = 0;
  21.  
  22.     if (set) SGREP = OFF;
  23.     m = strlen(Pattern);
  24. #if    DEBUG
  25.     fprintf(stderr, "checksg: len=%d, pat=%s, pat[len]=%d\n", m, Pattern, Pattern[m]);
  26. #endif
  27.     if(!(PAT_FILE || PAT_BUFFER) && (m <= D)) {
  28.         fprintf(stderr, "%s: size of pattern '%s' must be > #of errors %d\n", Progname, Pattern, D);
  29.         if (!EXITONERROR) {
  30.             errno = AGREP_ERROR;
  31.             return -1;
  32.         }
  33.         else exit(2);
  34.     }
  35.     SIMPLEPATTERN = ON;
  36.     for (i=0; i < m; i++) 
  37.     {
  38.         switch(Pattern[i])
  39.         {
  40.         case ';' : 
  41.             SIMPLEPATTERN = OFF; 
  42.             goto outoffor;
  43.         case ',' : 
  44.             SIMPLEPATTERN = OFF; 
  45.             goto outoffor;
  46.         case '.' : 
  47.             SIMPLEPATTERN = OFF; 
  48.             goto outoffor;
  49.         case '*' : 
  50.             SIMPLEPATTERN = OFF; 
  51.             goto outoffor;
  52.         case '-' : 
  53.             SIMPLEPATTERN = OFF; 
  54.             goto outoffor;
  55.         case '[' : 
  56.             SIMPLEPATTERN = OFF; 
  57.             goto outoffor;
  58.         case ']' : 
  59.             SIMPLEPATTERN = OFF; 
  60.             goto outoffor;
  61.         case '(' : 
  62.             SIMPLEPATTERN = OFF; 
  63.             goto outoffor;
  64.         case ')' : 
  65.             SIMPLEPATTERN = OFF; 
  66.             goto outoffor;
  67.         case '<' : 
  68.             SIMPLEPATTERN = OFF; 
  69.             goto outoffor;
  70.         case '>' : 
  71.             SIMPLEPATTERN = OFF; 
  72.             goto outoffor;
  73.         case '^' : 
  74.             NOTSGREP = 1;
  75.             if(D > 0) SIMPLEPATTERN = OFF; 
  76.             goto outoffor;
  77.         case '$' : 
  78.             NOTSGREP = 1;
  79.             if(D > 0) SIMPLEPATTERN = OFF; 
  80.             goto outoffor;
  81.         case '|' : 
  82.             SIMPLEPATTERN = OFF; 
  83.             goto outoffor;
  84.         case '#' : 
  85.             SIMPLEPATTERN = OFF; 
  86.             goto outoffor;
  87.         case '{':
  88.             SIMPLEPATTERN = OFF;
  89.             goto outoffor;
  90.         case '}':
  91.             SIMPLEPATTERN = OFF;
  92.             goto outoffor;
  93.         case '~':
  94.             SIMPLEPATTERN = OFF;
  95.             goto outoffor;
  96.         case '\\' : 
  97.         {    /* Should I DO the left shift Pattern including Pattern[m] which is '\0', or just ignore the next character after '\\'????? */
  98.             if (set) {    /* preprocess and maskgen figure out what to do */
  99.                 i++;    /* in addition to for loop ++ */
  100.             }
  101.             else {    /* maskgen won't be called if we can help it, so shift it to make it verbatim */
  102.                 /*
  103.                 int j;
  104.                 for (j=i; j<m; j++) Pattern[j] = Pattern[j+1];
  105.                 m --;
  106.                 */
  107.                 i++;
  108.             }
  109.             break;
  110.         }
  111.         default  : 
  112.             break;
  113.         }
  114.     }
  115.  
  116. outoffor:
  117.     if (CONSTANT) SIMPLEPATTERN = ON;
  118.     if (SIMPLEPATTERN == OFF) return 0;
  119.     if (BESTMATCH) return 0;    /* can have errors, not simple */
  120.     if (!set && (D>0)) return 0;    /* errors, not simple */
  121.     if (NOUPPER && (D>0)) return 0;    /* errors, not simple */     
  122.     if (JUMP == ON) return 0;    /* I, S, D costs, not simple */
  123.     if (I == 0) return 0;        /* I has 0 cost not 1, not simple */
  124.     if (LINENUM) return 0;        /* can't use mgrep, so not simple */
  125.     if (WORDBOUND && (D > 0)) return 0; /* errors, not simple */  
  126.     if (WHOLELINE && (D > 0)) return 0; /* errors, not simple */  
  127.     if (SILENT) return 1;        /* dont care output, so dont care pat */
  128.  
  129.     if (set) {
  130.         if (!NOTSGREP || CONSTANT) SGREP = ON;
  131.         if (m >= 16) DNA = ON;
  132.         for(i=0; i<m; i++) {
  133.             c = Pattern[i];
  134.             if(c == 'a' || c == 'c' || c == 't' || c == 'g' ) ;
  135.             else DNA = OFF;
  136.         }
  137.     }
  138.  
  139. #if    0
  140.     /* Ditch this: sgrep does it internally anyway */
  141.     if (SGREP) {    /* => set MUST be on */
  142.         for (i=0; i < m; i++) 
  143.         {
  144.         switch(Pattern[i])
  145.         {
  146.         case '\\' : 
  147.             for (j=i; j<m; j++) Pattern[j] = Pattern[j+1];
  148.             m --;
  149.             break;
  150.         default  : 
  151.             break;
  152.         }
  153.         }
  154.     }
  155. #endif    /*0*/
  156.     return 1;            /* remains simple */
  157. }
  158.